#  Модуль 1 

## I пара

### 1 Установка и настройка Python 

* [Python](https://www.python.org/)

### 2 Основные арифметические операции

* базовые `+ - * / **`

### 3 Приоритеты арифметических операций

Давайте теперь посмотрим, что будет, если выполнить команду:

> 27 ** 1/3

Получим значение `9`. 

Почему так произошло? 

Ведь кубический корень из 27 – это 3, а не 9? 

Все дело в приоритете арифметических операций (проще говоря, в последовательности их выполнения). 

Приоритет у оператора возведения в степень ** - наибольший. 

Поэтому здесь сначала 27 возводится в степень 1, а затем, 27 делится на 3. 

Получаем искомое значение 9.

Если нам нужно изменить порядок вычисления, то есть, приоритеты, то следует использовать круглые скобки:

> 27 ** (1/3)

Теперь видим значение `3`. 

То есть, по правилам математики, сначала производятся вычисления в круглых скобках, а затем, все остальное в порядке приоритетов.

Приведу еще один пример, чтобы все было понятно:
```python 
2 + 3 * 5    # 17
(2 + 3) * 5  # 25
```

То есть, приоритеты работают так, как нас учили на школьных уроках математики.

Я думаю, здесь все должно быть понятно. 
Также не забывайте, что все арифметические операторы выполняются слева-направо (кроме оператора возведения в степень), поэтому в строчке:

> 32 / 4 * 2

сначала будет выполнено деление на 4, а затем, результат умножается на 2.

---
### [4 Практика арифметика](/module-1/2_arithmetic.md)

----
в чем разница
```
5 * 6
2 * 4.5
```
----

## 5 Операции `// % `

```python
d3 = 7 // 2
d3 = -7 // 2 # ?
```
Четыре возможные ситуации:

```python
9 % 5   # значение 4 (9 - 5)
-9 % 5  # значение 1 (-9 – (-10) = 1)
9 % -5  # значение -1 (9 – 10 = -1)
-9 % -5 # значение -4 (-9 – (-5) = -4)
```
При вычислении `-9 % 5` по правилам математики следует взять наименьшее целое, делящееся на 5. 

Здесь – это значение -10. 

А, далее, как и прежде, вычисляем разность между наименьшим, кратным `5 и -9`:

> -9 – (-10) = 1

При вычислении 9 % -5, когда делитель отрицательное число, следует выбирать наибольшее целое, кратное 5. 

Это значение 10. 

А, далее, также вычисляется разность:

> 9 – 10 = -1

В последнем варианте -9 % -5 следует снова выбирать наибольшее целое (так как делитель отрицателен), получаем -5, а затем, вычислить разность:

> -9 – (-5) = -4


### 6 syntax sugar

```python
+= # Присвоение результата сложения
-= # Присвоение результата вычитания
*= # Присвоение результата умножения
/= # Присвоение результата от деления
//= # Присвоение результата целочисленного деления
**= # Присвоение степени числа
%= # Присвоение остатка от деления
```

## 7 Встроенные функции `abs, round, as_integer_ratio(), divmod(), is_integer(), sum, min, max, pow`

```python

x = -2.5
print(abs(x)) # что делает эта операция
```


```python

x = -1/3
print(round(x,5)) # что делает эта операция
print(round(x,2)) # что делает эта операция
print(round(78756, -3)) # что делает эта операция
print (0.1 + 0.1 + 0.1)
```


* пример с курсом доллара, минуты, секунды, дни недели 
* 0.1.as_integer_ratio()
* 2.5.as_integer_ratio()

`IEE754`
### 8 Установка IDE


* [Pycharm](https://www.jetbrains.com/pycharm/download/download-thanks.html?platform=windows&code=PCC)

* Настройка IDLE
- Интерфейс
- Горячие кнопки

### 9 Типизация данных. 

* Функция type()

```python
x = 1
print(type(x))
print(1, x.__sizeof__())

x = 10**10
print(type(x))
print('10**20', x.__sizeof__())

x = 3.14

print(type(x))
print(x.__sizeof__())


x = "строка"

print(type(x))
print(x.__sizeof__())

x = "string"

print(type(x))
print(x.__sizeof__())


x = 0.1 + 0.1 + 0.1
print(x)
0.1.as_integer_ratio()
```
* что весит больше `float` или `int` или `string`?
* типа данных `char` нет.

```python
a = 1
b = 1.0
c = '1'
d = 1e1

print (a.__sizeof__()) #28
print (b.__sizeof__()) # 24
print (c.__sizeof__()) #50
print (d.__sizeof__()) #24
```

## 10 Ссылочная модель в Python, функция id(), оператор is

```python
a = "some string"
b = a
id(a)  # 139739990935280
id(b)  # 139739990935280
print(a is b)  # => True
```

<!-- Функция id возвращает уникальный идентификатор объекта, 
который вы ей передаете в качестве аргумента и по ссылке. -->

Когда мы присваиваем значение одной переменной другой, фактически создается
новая именованная ссылка на исходное значение. 

Поэтому `id(a) и id(b)` возвращают одинаковый результат.

Оператор `is` проверяет равенство идентификаторов своих операндов. 
В этом примере обе переменные ссылаются на один объект, поэтому проверка `a is` b дает `True`.

### Типы присваиваний

* каскадное присваивание: `a = b = c = 0`
* множественное присваивание: `a, b = 1, 2`
* оператор звездочка

## 11 Аннотация типов данных

```python
price: int = 5
title: str

```

* Строгая типизация операция сложения — это операция для типа «числа». 

если применить эту операцию не к двум числам, а к числу и строке?


# ! строгая динамическая типизация !

### 12 Названия переменных
```python
печать = print
print = 'слово'
печать(print)
```

* camelCase
* snake_case


### 13 Функция print

Для вывода информации на консоль предназначена встроенная функция `print()`. 

При вызове этой функции ей в скобках передается выводимое значение


```python

аргументы = 1, 2, "python"

print(аргументы)

```

* Сепаратор - параметр `sep`

```python

print(1, 2, "python", 21, sep=' and ')

```

* Разделитель - параметр `end`


```python

print("python", end=" и ")
print("python")

```


## 14 Функция input()

```python
a = input()
b = input("Введи число")
a,b = input("Введи 2 числа")
```

```python

a,b = input("Введи 2 числа")
print (a * b) # ?
a = int(input())
```


##  [15 Практика математика](/module-1/3_math.md)


> P.S 
* В математике числа обладают естественной иерархией. 
* Например, все натуральные числа являются целыми, а все целые числа — рациональными. 
* Все рациональные числа — это вещественные числа, а все вещественные числа — это комплексные числа.



## II пара

### 1 Операции со строками

```python
s1 = "Панда" # в двойных кавычках
s2 = 'Panda' # или в одинарных (апострофах):
s2 = Panda # ошибка

text = '''Я Python бы выучил только за то,
что есть популярные курсы.
Много хороших курсов!''' # многострочная строка

a = ""
a = " "
s1 = "Я люблю"
s2 = "язык Python
s3 = s1 + s2
print(s3)

s3 = s1 + " " + s2
s3 = s1 + 5 # ошибка
s3 = s1 + str(5) 

"ха " * 5
"ха " * 5.5

a = "hello"
len(a)
len("") # 0
len("Python")

'ab' in "abracadabra"
'abc' in "abracadabra"

a == "hello" # ==
a == "Hello"
a != "hello"
a != "hello "

'кот' > 'кит'
'кот' > 'кот'
'Кот ' > 'кот'
ord('К')
ord('к')
```

#### Резюме

* `+` (конкатенация) – соединение строк;
* `*` (дублирование) – размножение строкового фрагмента;
* `str()` – функция для преобразования аргумента в строковое представление;
* `len()` – вычисление длины строки;
* `in` – оператор для проверки вхождения подстроки в строку;
* операторы сравнения: ==   !=   >   <
* `ord()` – определение кода символа.


### 2 Форматированный вывод

```python
x = 5.76
y = -8
print("Координаты точки: x = ", x, "; y = ", y)
print(f"Координаты точки: x = {x}; y = {y}")

age=18; name="Александр"
"Меня зовут {0}, мне {1} и я люблю язык Python.".format(name, age)
msg = "Меня зовут {0}, мне {1} и я люблю язык Python.".format(name, age)
"Меня зовут {fio}, мне {old} и я люблю язык Python. {fio}".format(fio=name, old=age)

"Меня зовут {fio}, мне {old} и я люблю язык Python. {fio}".format(old=age, fio=name)
f"Меня зовут {name}, мне {age} и я люблю язык Python."
f"Меня зовут {name.upper()}, мне {age*2} и я люблю язык Python."
f"Меня зовут {len(name)}, мне {14*2} и я люблю язык Python."
template = "%s — главное достоинство программиста. (%s)"
print(template % ("Лень", "Larry Wall"))

```


### 3 системы счисления

```python
x = 15

print(bin(x))
print(oct(x))
print(hex(x))
```

* Кол-во бит в числе
```python
x = 16

print(bin(x))
print(x.bit_count())
print(x.bit_length())
```



```python
print(f'{10:b}') #двоичная СС
print(f'{10:o}') #8-ричная СС
print(f'{10:x}') #16-ричная СС
print(f'{10:X}') #16-ричная СС
print(f'{10:e}') # научная (экспоненциальный вид)
print(f'{10:E}') # научная (экспоненциальный вид)
print(f'{10.5:f}') # тип float (6-символов после запятой)
print(f'{100:c}') # символ юникода
```

#### Обратный перевод - функция int


> P.S 
* В математике числа обладают естественной иерархией. 
* Например, все натуральные числа являются целыми, а все целые числа — рациональными. 
* Все рациональные числа — это вещественные числа, а все вещественные числа — это комплексные числа.


### 4 Модификаторы f-строк

```python
num = 2 / 3
print(num)
print(f"{num:.3f}") # выводим число с точностью до 3-го знака
0.6666666666666666
0.667
```

### 5 Модуль math

```python
math.ceil(5.2)
math.ceil(-5.2)
math.floor(5.99)
math.floor(-3.3)
math.trunc(5.8)

math.log2(4)
math.log10(100)
math.log(2.7)
math.log(27, 3) # по основанию 3
math.sqrt(49)
math.sin(3.14/2)
math.cos(0)
math.pi
math.e
```



## 6 Побитовые операции 

```python
x = 4
y = 3
print("Побитовое или:", x | y)
print("Побитовое исключающее или:", x ^ y)
print("Побитовое и:", x & y)
print("Битовый сдвиг влево:", x << 3)
print("Битовый сдвиг вправо:", x >> 1)
print("Инверсия битов:", ~x)
```

##  [7 Практика строки](module-1\4_string.md)

## 8 Логический тип bool. Операторы сравнения `>=, !=, <=, ==и` операторы `and, or, not`

```python
4 > 2
4 > 7
a = 5
b = 7.8
a <= b
res = a > b
type(res)
x % 2 == 0
x % 2 != 0
a % 3 == 0

print (1 or 3) #?
print (1 and 3) #?
x % 2 == 0 or x % 3 == 0


bool(1)
bool(-10)
```


##  [9 Домашнее задание](/module-1/5_homework.md)